home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / PInterfaces / ImageCompression.p < prev    next >
Encoding:
Text File  |  1996-05-01  |  35.2 KB  |  894 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        ImageCompression.p
  3.  
  4.      Contains:    QuickTime Image Compression Interfaces.
  5.  
  6.      Version:    Technology:    QuickTime 2.1
  7.                  Release:    Universal Interfaces 3.0d3 on Copland DR1
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT ImageCompression;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __IMAGECOMPRESSION__}
  28. {$SETC __IMAGECOMPRESSION__ := 1}
  29.  
  30. {$I+}
  31. {$SETC ImageCompressionIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __TYPES__}
  35. {$I Types.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __QUICKDRAW__}
  38. {$I Quickdraw.p}
  39. {$ENDC}
  40. {$IFC UNDEFINED __QDOFFSCREEN__}
  41. {$I QDOffscreen.p}
  42. {$ENDC}
  43. {$IFC UNDEFINED __COMPONENTS__}
  44. {$I Components.p}
  45. {$ENDC}
  46. {$IFC UNDEFINED __WINDOWS__}
  47. {$I Windows.p}
  48. {$ENDC}
  49. {$IFC UNDEFINED __STANDARDFILE__}
  50. {$I StandardFile.p}
  51. {$ENDC}
  52.  
  53. {$PUSH}
  54. {$ALIGN MAC68K}
  55. {$LibExport+}
  56.  
  57. {$IFC FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE }
  58.  
  59. TYPE
  60.     MatrixRecordPtr = ^MatrixRecord;
  61.     MatrixRecord = RECORD
  62.         matrix:                    ARRAY [0..2,0..2] OF Fixed;
  63.     END;
  64.  
  65.     FixedPointPtr = ^FixedPoint;
  66.     FixedPoint = RECORD
  67.         x:                        Fixed;
  68.         y:                        Fixed;
  69.     END;
  70.  
  71.     FixedRectPtr = ^FixedRect;
  72.     FixedRect = RECORD
  73.         left:                    Fixed;
  74.         top:                    Fixed;
  75.         right:                    Fixed;
  76.         bottom:                    Fixed;
  77.     END;
  78.  
  79. {  These are the bits that are set in the Component flags, and also in the codecInfo struct.  }
  80.  
  81. CONST
  82.     codecInfoDoes1                = $00000001;
  83.     codecInfoDoes2                = $00000002;
  84.     codecInfoDoes4                = $00000004;
  85.     codecInfoDoes8                = $00000008;
  86.     codecInfoDoes16                = $00000010;
  87.     codecInfoDoes32                = $00000020;
  88.     codecInfoDoesDither            = $00000040;
  89.     codecInfoDoesStretch        = $00000080;
  90.     codecInfoDoesShrink            = $00000100;
  91.     codecInfoDoesMask            = $00000200;
  92.     codecInfoDoesTemporal        = $00000400;
  93.     codecInfoDoesDouble            = $00000800;
  94.     codecInfoDoesQuad            = $00001000;
  95.     codecInfoDoesHalf            = $00002000;
  96.     codecInfoDoesQuarter        = $00004000;
  97.     codecInfoDoesRotate            = $00008000;
  98.     codecInfoDoesHorizFlip        = $00010000;
  99.     codecInfoDoesVertFlip        = $00020000;
  100.     codecInfoDoesSkew            = $00040000;
  101.     codecInfoDoesBlend            = $00080000;
  102.     codecInfoDoesWarp            = $00100000;
  103.     codecInfoDoesRecompress        = $00200000;
  104.     codecInfoDoesSpool            = $00400000;
  105.     codecInfoDoesRateConstrain    = $00800000;
  106.  
  107.     codecInfoDepth1                = $00000001;
  108.     codecInfoDepth2                = $00000002;
  109.     codecInfoDepth4                = $00000004;
  110.     codecInfoDepth8                = $00000008;
  111.     codecInfoDepth16            = $00000010;
  112.     codecInfoDepth32            = $00000020;
  113.     codecInfoDepth24            = $00000040;
  114.     codecInfoDepth33            = $00000080;
  115.     codecInfoDepth34            = $00000100;
  116.     codecInfoDepth36            = $00000200;
  117.     codecInfoDepth40            = $00000400;
  118.     codecInfoStoresClut            = $00000800;
  119.     codecInfoDoesLossless        = $00001000;
  120.     codecInfoSequenceSensitive    = $00002000;
  121.  
  122.     codecFlagUseImageBuffer        = $00000001;
  123.     codecFlagUseScreenBuffer    = $00000002;
  124.     codecFlagUpdatePrevious        = $00000004;
  125.     codecFlagNoScreenUpdate        = $00000008;
  126.     codecFlagWasCompressed        = $00000010;
  127.     codecFlagDontOffscreen        = $00000020;
  128.     codecFlagUpdatePreviousComp    = $00000040;
  129.     codecFlagForceKeyFrame        = $00000080;
  130.     codecFlagOnlyScreenUpdate    = $00000100;
  131.     codecFlagLiveGrab            = $00000200;
  132.     codecFlagDontUseNewImageBuffer = $00000400;
  133.     codecFlagInterlaceUpdate    = $00000800;
  134.     codecFlagCatchUpDiff        = $00001000;
  135.     codecFlagUsedNewImageBuffer    = $00004000;
  136.     codecFlagUsedImageBuffer    = $00008000;
  137.  
  138.                                                                 {  The minimum data size for spooling in or out data  }
  139.     codecMinimumDataSize        = 32768;
  140.  
  141.     compressorComponentType        = 'imco';                        {  the type for "Components" which compress images  }
  142.     decompressorComponentType    = 'imdc';                        {  the type for "Components" which decompress images  }
  143.  
  144.  
  145. TYPE
  146.     CompressorComponent                    = Component;
  147.     DecompressorComponent                = Component;
  148.     CodecComponent                        = Component;
  149.  
  150. CONST
  151.     anyCodec                    = 0;                            {  take first working codec of given type  }
  152.     bestSpeedCodec                = -1;                            {  take fastest codec of given type  }
  153.     bestFidelityCodec            = -2;                            {  take codec which is most accurate  }
  154.     bestCompressionCodec        = -3;                            {  take codec of given type that is most accurate  }
  155.  
  156.  
  157. TYPE
  158.     CodecType                            = LONGINT;
  159.     CodecFlags                            = INTEGER;
  160.     CodecQ                                = LONGINT;
  161.  
  162. CONST
  163.     codecLosslessQuality        = $00000400;
  164.     codecMaxQuality                = $000003FF;
  165.     codecMinQuality                = $00000000;
  166.     codecLowQuality                = $00000100;
  167.     codecNormalQuality            = $00000200;
  168.     codecHighQuality            = $00000300;
  169.  
  170.     codecCompletionSource        = $01;                            {  asynchronous codec is done with source data  }
  171.     codecCompletionDest            = $02;                            {  asynchronous codec is done with destination data  }
  172.     codecCompletionDontUnshield    = $04;                            {  on dest complete don't unshield cursor  }
  173.  
  174.     codecProgressOpen            = 0;
  175.     codecProgressUpdatePercent    = 1;
  176.     codecProgressClose            = 2;
  177.  
  178.  
  179. TYPE
  180.     ICMDataProcPtr = ProcPtr;  { FUNCTION ICMData(VAR dataP: Ptr; bytesNeeded: LONGINT; refcon: LONGINT): OSErr; }
  181.  
  182.     ICMFlushProcPtr = ProcPtr;  { FUNCTION ICMFlush(data: Ptr; bytesAdded: LONGINT; refcon: LONGINT): OSErr; }
  183.  
  184.     ICMCompletionProcPtr = ProcPtr;  { PROCEDURE ICMCompletion(result: OSErr; flags: INTEGER; refcon: LONGINT); }
  185.  
  186.     ICMProgressProcPtr = ProcPtr;  { FUNCTION ICMProgress(message: INTEGER; completeness: Fixed; refcon: LONGINT): OSErr; }
  187.  
  188.     StdPixProcPtr = ProcPtr;  { PROCEDURE StdPix(VAR src: PixMap; VAR srcRect: Rect; VAR matrix: MatrixRecord; mode: INTEGER; mask: RgnHandle; VAR matte: PixMap; VAR matteRect: Rect; flags: INTEGER); }
  189.  
  190.     ICMAlignmentProcPtr = ProcPtr;  { PROCEDURE ICMAlignment(VAR rp: Rect; refcon: LONGINT); }
  191.  
  192.     ICMMemoryDisposedProcPtr = ProcPtr;  { PROCEDURE ICMMemoryDisposed(memoryBlock: Ptr; refcon: UNIV Ptr); }
  193.  
  194.     ICMDataUPP = UniversalProcPtr;
  195.     ICMFlushUPP = UniversalProcPtr;
  196.     ICMCompletionUPP = UniversalProcPtr;
  197.     ICMProgressUPP = UniversalProcPtr;
  198.     StdPixUPP = UniversalProcPtr;
  199.     ICMAlignmentUPP = UniversalProcPtr;
  200.     ICMMemoryDisposedUPP = UniversalProcPtr;
  201.     ImageSequence                        = LONGINT;
  202.     ImageSequenceDataSource                = LONGINT;
  203.     ICMProgressProcRecordPtr = ^ICMProgressProcRecord;
  204.     ICMProgressProcRecord = RECORD
  205.         progressProc:            ICMProgressUPP;
  206.         progressRefCon:            LONGINT;
  207.     END;
  208.  
  209.     ICMCompletionProcRecordPtr = ^ICMCompletionProcRecord;
  210.     ICMCompletionProcRecord = RECORD
  211.         completionProc:            ICMCompletionUPP;
  212.         completionRefCon:        LONGINT;
  213.     END;
  214.  
  215.     ICMDataProcRecordPtr = ^ICMDataProcRecord;
  216.     ICMDataProcRecord = RECORD
  217.         dataProc:                ICMDataUPP;
  218.         dataRefCon:                LONGINT;
  219.     END;
  220.  
  221.     ICMFlushProcRecordPtr = ^ICMFlushProcRecord;
  222.     ICMFlushProcRecord = RECORD
  223.         flushProc:                ICMFlushUPP;
  224.         flushRefCon:            LONGINT;
  225.     END;
  226.  
  227.     ICMAlignmentProcRecordPtr = ^ICMAlignmentProcRecord;
  228.     ICMAlignmentProcRecord = RECORD
  229.         alignmentProc:            ICMAlignmentUPP;
  230.         alignmentRefCon:        LONGINT;
  231.     END;
  232.  
  233.     DataRateParamsPtr = ^DataRateParams;
  234.     DataRateParams = RECORD
  235.         dataRate:                LONGINT;
  236.         dataOverrun:            LONGINT;
  237.         frameDuration:            LONGINT;
  238.         keyFrameRate:            LONGINT;
  239.         minSpatialQuality:        CodecQ;
  240.         minTemporalQuality:        CodecQ;
  241.     END;
  242.  
  243.     ImageDescriptionPtr = ^ImageDescription;
  244.     ImageDescription = PACKED RECORD
  245.         idSize:                    LONGINT;                                {  total size of ImageDescription including extra data ( CLUTs and other per sequence data  }
  246.         cType:                    CodecType;                                {  what kind of codec compressed this data  }
  247.         resvd1:                    LONGINT;                                {  reserved for Apple use  }
  248.         resvd2:                    INTEGER;                                {  reserved for Apple use  }
  249.         dataRefIndex:            INTEGER;                                {  set to zero   }
  250.         version:                INTEGER;                                {  which version is this data  }
  251.         revisionLevel:            INTEGER;                                {  what version of that codec did this  }
  252.         vendor:                    LONGINT;                                {  whose  codec compressed this data  }
  253.         temporalQuality:        CodecQ;                                    {  what was the temporal quality factor   }
  254.         spatialQuality:            CodecQ;                                    {  what was the spatial quality factor  }
  255.         width:                    INTEGER;                                {  how many pixels wide is this data  }
  256.         height:                    INTEGER;                                {  how many pixels high is this data  }
  257.         hRes:                    Fixed;                                    {  horizontal resolution  }
  258.         vRes:                    Fixed;                                    {  vertical resolution  }
  259.         dataSize:                LONGINT;                                {  if known, the size of data for this image descriptor  }
  260.         frameCount:                INTEGER;                                {  number of frames this description applies to  }
  261.         name:                    Str31;                                    {  name of codec ( in case not installed )   }
  262.         depth:                    INTEGER;                                {  what depth is this data (1-32) or ( 33-40 grayscale )  }
  263.         clutID:                    INTEGER;                                {  clut id or if 0 clut follows  or -1 if no clut  }
  264.     END;
  265.  
  266.     ImageDescriptionHandle                = ^ImageDescriptionPtr;
  267.     CodecInfoPtr = ^CodecInfo;
  268.     CodecInfo = PACKED RECORD
  269.         typeName:                Str31;                                    {  name of the codec type i.e.: 'Apple Image Compression'  }
  270.         version:                INTEGER;                                {  version of the codec data that this codec knows about  }
  271.         revisionLevel:            INTEGER;                                {  revision level of this codec i.e: 0x00010001 (1.0.1)  }
  272.         vendor:                    LONGINT;                                {  Maker of this codec i.e: 'appl'  }
  273.         decompressFlags:        LONGINT;                                {  codecInfo flags for decompression capabilities  }
  274.         compressFlags:            LONGINT;                                {  codecInfo flags for compression capabilities  }
  275.         formatFlags:            LONGINT;                                {  codecInfo flags for compression format details  }
  276.         compressionAccuracy:    UInt8;                                    {  measure (1-255) of accuracy of this codec for compress (0 if unknown)  }
  277.         decompressionAccuracy:    UInt8;                                    {  measure (1-255) of accuracy of this codec for decompress (0 if unknown)  }
  278.         compressionSpeed:        INTEGER;                                {  ( millisecs for compressing 320x240 on base mac II) (0 if unknown)   }
  279.         decompressionSpeed:        INTEGER;                                {  ( millisecs for decompressing 320x240 on mac II)(0 if unknown)   }
  280.         compressionLevel:        UInt8;                                    {  measure (1-255) of compression level of this codec (0 if unknown)   }
  281.         resvd:                    UInt8;                                    {  pad  }
  282.         minimumHeight:            INTEGER;                                {  minimum height of image (block size)  }
  283.         minimumWidth:            INTEGER;                                {  minimum width of image (block size)  }
  284.         decompressPipelineLatency: INTEGER;                                {  in milliseconds ( for asynchronous codecs )  }
  285.         compressPipelineLatency: INTEGER;                                {  in milliseconds ( for asynchronous codecs )  }
  286.         privateData:            LONGINT;
  287.     END;
  288.  
  289.     CodecNameSpecPtr = ^CodecNameSpec;
  290.     CodecNameSpec = RECORD
  291.         codec:                    CodecComponent;
  292.         cType:                    CodecType;
  293.         typeName:                Str31;
  294.         name:                    Handle;
  295.     END;
  296.  
  297.     CodecNameSpecListPtr = ^CodecNameSpecList;
  298.     CodecNameSpecList = RECORD
  299.         count:                    INTEGER;
  300.         list:                    ARRAY [0..0] OF CodecNameSpec;
  301.     END;
  302.  
  303.  
  304. CONST
  305.     defaultDither                = 0;
  306.     forceDither                    = 1;
  307.     suppressDither                = 2;
  308.     useColorMatching            = 4;
  309.  
  310.  
  311. TYPE
  312.     ICMFrameTimeRecordPtr = ^ICMFrameTimeRecord;
  313.     ICMFrameTimeRecord = RECORD
  314.         value:                    wide;                                    {  frame time }
  315.         scale:                    LONGINT;                                {  timescale of value/duration fields }
  316.         base:                    Ptr;                                    {  timebase }
  317.         duration:                LONGINT;                                {  duration frame is to be displayed (0 if unknown) }
  318.         rate:                    Fixed;                                    {  rate of timebase relative to wall-time }
  319.     END;
  320.  
  321.     ICMFrameTimePtr                        = ^ICMFrameTimeRecord;
  322.  
  323. CONST
  324.     uppICMDataProcInfo = $00000FE0;
  325.     uppICMFlushProcInfo = $00000FE0;
  326.     uppICMCompletionProcInfo = $00000E80;
  327.     uppICMProgressProcInfo = $00000FA0;
  328.     uppStdPixProcInfo = $002FEFC0;
  329.     uppICMAlignmentProcInfo = $000003C0;
  330.     uppICMMemoryDisposedProcInfo = $000003C0;
  331.  
  332. FUNCTION NewICMDataProc(userRoutine: ICMDataProcPtr): ICMDataUPP;
  333.     {$IFC NOT GENERATINGCFM }
  334.     INLINE $2E9F;
  335.     {$ENDC}
  336.  
  337. FUNCTION NewICMFlushProc(userRoutine: ICMFlushProcPtr): ICMFlushUPP;
  338.     {$IFC NOT GENERATINGCFM }
  339.     INLINE $2E9F;
  340.     {$ENDC}
  341.  
  342. FUNCTION NewICMCompletionProc(userRoutine: ICMCompletionProcPtr): ICMCompletionUPP;
  343.     {$IFC NOT GENERATINGCFM }
  344.     INLINE $2E9F;
  345.     {$ENDC}
  346.  
  347. FUNCTION NewICMProgressProc(userRoutine: ICMProgressProcPtr): ICMProgressUPP;
  348.     {$IFC NOT GENERATINGCFM }
  349.     INLINE $2E9F;
  350.     {$ENDC}
  351.  
  352. FUNCTION NewStdPixProc(userRoutine: StdPixProcPtr): StdPixUPP;
  353.     {$IFC NOT GENERATINGCFM }
  354.     INLINE $2E9F;
  355.     {$ENDC}
  356.  
  357. FUNCTION NewICMAlignmentProc(userRoutine: ICMAlignmentProcPtr): ICMAlignmentUPP;
  358.     {$IFC NOT GENERATINGCFM }
  359.     INLINE $2E9F;
  360.     {$ENDC}
  361.  
  362. FUNCTION NewICMMemoryDisposedProc(userRoutine: ICMMemoryDisposedProcPtr): ICMMemoryDisposedUPP;
  363.     {$IFC NOT GENERATINGCFM }
  364.     INLINE $2E9F;
  365.     {$ENDC}
  366.  
  367. FUNCTION CallICMDataProc(VAR dataP: Ptr; bytesNeeded: LONGINT; refcon: LONGINT; userRoutine: ICMDataUPP): OSErr;
  368.     {$IFC NOT GENERATINGCFM}
  369.     INLINE $205F, $4E90;
  370.     {$ENDC}
  371.  
  372. FUNCTION CallICMFlushProc(data: Ptr; bytesAdded: LONGINT; refcon: LONGINT; userRoutine: ICMFlushUPP): OSErr;
  373.     {$IFC NOT GENERATINGCFM}
  374.     INLINE $205F, $4E90;
  375.     {$ENDC}
  376.  
  377. PROCEDURE CallICMCompletionProc(result: OSErr; flags: INTEGER; refcon: LONGINT; userRoutine: ICMCompletionUPP);
  378.     {$IFC NOT GENERATINGCFM}
  379.     INLINE $205F, $4E90;
  380.     {$ENDC}
  381.  
  382. FUNCTION CallICMProgressProc(message: INTEGER; completeness: Fixed; refcon: LONGINT; userRoutine: ICMProgressUPP): OSErr;
  383.     {$IFC NOT GENERATINGCFM}
  384.     INLINE $205F, $4E90;
  385.     {$ENDC}
  386.  
  387. PROCEDURE CallStdPixProc(VAR src: PixMap; VAR srcRect: Rect; VAR matrix: MatrixRecord; mode: INTEGER; mask: RgnHandle; VAR matte: PixMap; VAR matteRect: Rect; flags: INTEGER; userRoutine: StdPixUPP);
  388.     {$IFC NOT GENERATINGCFM}
  389.     INLINE $205F, $4E90;
  390.     {$ENDC}
  391.  
  392. PROCEDURE CallICMAlignmentProc(VAR rp: Rect; refcon: LONGINT; userRoutine: ICMAlignmentUPP);
  393.     {$IFC NOT GENERATINGCFM}
  394.     INLINE $205F, $4E90;
  395.     {$ENDC}
  396.  
  397. PROCEDURE CallICMMemoryDisposedProc(memoryBlock: Ptr; refcon: UNIV Ptr; userRoutine: ICMMemoryDisposedUPP);
  398.     {$IFC NOT GENERATINGCFM}
  399.     INLINE $205F, $4E90;
  400.     {$ENDC}
  401. FUNCTION CodecManagerVersion(VAR version: LONGINT): OSErr;
  402.     {$IFC NOT GENERATINGCFM}
  403.     INLINE $7000, $AAA3;
  404.     {$ENDC}
  405. FUNCTION GetCodecNameList(VAR list: CodecNameSpecListPtr; showAll: INTEGER): OSErr;
  406.     {$IFC NOT GENERATINGCFM}
  407.     INLINE $7001, $AAA3;
  408.     {$ENDC}
  409. FUNCTION DisposeCodecNameList(list: CodecNameSpecListPtr): OSErr;
  410.     {$IFC NOT GENERATINGCFM}
  411.     INLINE $700F, $AAA3;
  412.     {$ENDC}
  413. FUNCTION GetCodecInfo(VAR info: CodecInfo; cType: CodecType; codec: CodecComponent): OSErr;
  414.     {$IFC NOT GENERATINGCFM}
  415.     INLINE $7003, $AAA3;
  416.     {$ENDC}
  417. FUNCTION GetMaxCompressionSize(src: PixMapHandle; {CONST}VAR srcRect: Rect; colorDepth: INTEGER; quality: CodecQ; cType: CodecType; codec: CompressorComponent; VAR size: LONGINT): OSErr;
  418.     {$IFC NOT GENERATINGCFM}
  419.     INLINE $7004, $AAA3;
  420.     {$ENDC}
  421. FUNCTION GetCompressionTime(src: PixMapHandle; {CONST}VAR srcRect: Rect; colorDepth: INTEGER; cType: CodecType; codec: CompressorComponent; VAR spatialQuality: CodecQ; VAR temporalQuality: CodecQ; VAR compressTime: LONGINT): OSErr;
  422.     {$IFC NOT GENERATINGCFM}
  423.     INLINE $7005, $AAA3;
  424.     {$ENDC}
  425. FUNCTION CompressImage(src: PixMapHandle; {CONST}VAR srcRect: Rect; quality: CodecQ; cType: CodecType; desc: ImageDescriptionHandle; data: Ptr): OSErr;
  426.     {$IFC NOT GENERATINGCFM}
  427.     INLINE $7006, $AAA3;
  428.     {$ENDC}
  429. FUNCTION FCompressImage(src: PixMapHandle; {CONST}VAR srcRect: Rect; colorDepth: INTEGER; quality: CodecQ; cType: CodecType; codec: CompressorComponent; clut: CTabHandle; flags: CodecFlags; bufferSize: LONGINT; flushProc: ICMFlushProcRecordPtr; progressProc: ICMProgressProcRecordPtr; desc: ImageDescriptionHandle; data: Ptr): OSErr;
  430.     {$IFC NOT GENERATINGCFM}
  431.     INLINE $7007, $AAA3;
  432.     {$ENDC}
  433. FUNCTION DecompressImage(data: Ptr; desc: ImageDescriptionHandle; dst: PixMapHandle; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; mask: RgnHandle): OSErr;
  434.     {$IFC NOT GENERATINGCFM}
  435.     INLINE $7008, $AAA3;
  436.     {$ENDC}
  437. FUNCTION FDecompressImage(data: Ptr; desc: ImageDescriptionHandle; dst: PixMapHandle; {CONST}VAR srcRect: Rect; matrix: MatrixRecordPtr; mode: INTEGER; mask: RgnHandle; matte: PixMapHandle; {CONST}VAR matteRect: Rect; accuracy: CodecQ; codec: DecompressorComponent; bufferSize: LONGINT; dataProc: ICMDataProcRecordPtr; progressProc: ICMProgressProcRecordPtr): OSErr;
  438.     {$IFC NOT GENERATINGCFM}
  439.     INLINE $7009, $AAA3;
  440.     {$ENDC}
  441. FUNCTION CompressSequenceBegin(VAR seqID: ImageSequence; src: PixMapHandle; prev: PixMapHandle; {CONST}VAR srcRect: Rect; {CONST}VAR prevRect: Rect; colorDepth: INTEGER; cType: CodecType; codec: CompressorComponent; spatialQuality: CodecQ; temporalQuality: CodecQ; keyFrameRate: LONGINT; clut: CTabHandle; flags: CodecFlags; desc: ImageDescriptionHandle): OSErr;
  442.     {$IFC NOT GENERATINGCFM}
  443.     INLINE $700A, $AAA3;
  444.     {$ENDC}
  445. FUNCTION CompressSequenceFrame(seqID: ImageSequence; src: PixMapHandle; {CONST}VAR srcRect: Rect; flags: CodecFlags; data: Ptr; VAR dataSize: LONGINT; VAR similarity: UInt8; asyncCompletionProc: ICMCompletionProcRecordPtr): OSErr;
  446.     {$IFC NOT GENERATINGCFM}
  447.     INLINE $700B, $AAA3;
  448.     {$ENDC}
  449. FUNCTION DecompressSequenceBegin(VAR seqID: ImageSequence; desc: ImageDescriptionHandle; port: CGrafPtr; gdh: GDHandle; {CONST}VAR srcRect: Rect; matrix: MatrixRecordPtr; mode: INTEGER; mask: RgnHandle; flags: CodecFlags; accuracy: CodecQ; codec: DecompressorComponent): OSErr;
  450.     {$IFC NOT GENERATINGCFM}
  451.     INLINE $700D, $AAA3;
  452.     {$ENDC}
  453. FUNCTION DecompressSequenceBeginS(VAR seqID: ImageSequence; desc: ImageDescriptionHandle; data: Ptr; dataSize: LONGINT; port: CGrafPtr; gdh: GDHandle; {CONST}VAR srcRect: Rect; matrix: MatrixRecordPtr; mode: INTEGER; mask: RgnHandle; flags: CodecFlags; accuracy: CodecQ; codec: DecompressorComponent): OSErr;
  454.     {$IFC NOT GENERATINGCFM}
  455.     INLINE $203C, $0030, $005D, $AAA3;
  456.     {$ENDC}
  457. FUNCTION DecompressSequenceFrame(seqID: ImageSequence; data: Ptr; inFlags: CodecFlags; VAR outFlags: CodecFlags; asyncCompletionProc: ICMCompletionProcRecordPtr): OSErr;
  458.     {$IFC NOT GENERATINGCFM}
  459.     INLINE $700E, $AAA3;
  460.     {$ENDC}
  461. FUNCTION DecompressSequenceFrameS(seqID: ImageSequence; data: Ptr; dataSize: LONGINT; inFlags: CodecFlags; VAR outFlags: CodecFlags; asyncCompletionProc: ICMCompletionProcRecordPtr): OSErr;
  462.     {$IFC NOT GENERATINGCFM}
  463.     INLINE $203C, $0016, $0047, $AAA3;
  464.     {$ENDC}
  465. FUNCTION DecompressSequenceFrameWhen(seqID: ImageSequence; data: Ptr; dataSize: LONGINT; inFlags: CodecFlags; VAR outFlags: CodecFlags; asyncCompletionProc: ICMCompletionProcRecordPtr; {CONST}VAR frameTime: ICMFrameTimeRecord): OSErr;
  466.     {$IFC NOT GENERATINGCFM}
  467.     INLINE $203C, $001A, $005E, $AAA3;
  468.     {$ENDC}
  469. FUNCTION CDSequenceFlush(seqID: ImageSequence): OSErr;
  470.     {$IFC NOT GENERATINGCFM}
  471.     INLINE $203C, $0004, $005F, $AAA3;
  472.     {$ENDC}
  473. FUNCTION SetDSequenceMatrix(seqID: ImageSequence; matrix: MatrixRecordPtr): OSErr;
  474.     {$IFC NOT GENERATINGCFM}
  475.     INLINE $7010, $AAA3;
  476.     {$ENDC}
  477. FUNCTION SetDSequenceMatte(seqID: ImageSequence; matte: PixMapHandle; {CONST}VAR matteRect: Rect): OSErr;
  478.     {$IFC NOT GENERATINGCFM}
  479.     INLINE $7011, $AAA3;
  480.     {$ENDC}
  481. FUNCTION SetDSequenceMask(seqID: ImageSequence; mask: RgnHandle): OSErr;
  482.     {$IFC NOT GENERATINGCFM}
  483.     INLINE $7012, $AAA3;
  484.     {$ENDC}
  485. FUNCTION SetDSequenceTransferMode(seqID: ImageSequence; mode: INTEGER; {CONST}VAR opColor: RGBColor): OSErr;
  486.     {$IFC NOT GENERATINGCFM}
  487.     INLINE $7013, $AAA3;
  488.     {$ENDC}
  489. FUNCTION SetDSequenceDataProc(seqID: ImageSequence; dataProc: ICMDataProcRecordPtr; bufferSize: LONGINT): OSErr;
  490.     {$IFC NOT GENERATINGCFM}
  491.     INLINE $7014, $AAA3;
  492.     {$ENDC}
  493. FUNCTION SetDSequenceAccuracy(seqID: ImageSequence; accuracy: CodecQ): OSErr;
  494.     {$IFC NOT GENERATINGCFM}
  495.     INLINE $7034, $AAA3;
  496.     {$ENDC}
  497. FUNCTION SetDSequenceSrcRect(seqID: ImageSequence; {CONST}VAR srcRect: Rect): OSErr;
  498.     {$IFC NOT GENERATINGCFM}
  499.     INLINE $7035, $AAA3;
  500.     {$ENDC}
  501. FUNCTION GetDSequenceImageBuffer(seqID: ImageSequence; VAR gworld: GWorldPtr): OSErr;
  502.     {$IFC NOT GENERATINGCFM}
  503.     INLINE $7015, $AAA3;
  504.     {$ENDC}
  505. FUNCTION GetDSequenceScreenBuffer(seqID: ImageSequence; VAR gworld: GWorldPtr): OSErr;
  506.     {$IFC NOT GENERATINGCFM}
  507.     INLINE $7016, $AAA3;
  508.     {$ENDC}
  509. FUNCTION SetCSequenceQuality(seqID: ImageSequence; spatialQuality: CodecQ; temporalQuality: CodecQ): OSErr;
  510.     {$IFC NOT GENERATINGCFM}
  511.     INLINE $7017, $AAA3;
  512.     {$ENDC}
  513. FUNCTION SetCSequencePrev(seqID: ImageSequence; prev: PixMapHandle; {CONST}VAR prevRect: Rect): OSErr;
  514.     {$IFC NOT GENERATINGCFM}
  515.     INLINE $7018, $AAA3;
  516.     {$ENDC}
  517. FUNCTION SetCSequenceFlushProc(seqID: ImageSequence; flushProc: ICMFlushProcRecordPtr; bufferSize: LONGINT): OSErr;
  518.     {$IFC NOT GENERATINGCFM}
  519.     INLINE $7033, $AAA3;
  520.     {$ENDC}
  521. FUNCTION SetCSequenceKeyFrameRate(seqID: ImageSequence; keyframerate: LONGINT): OSErr;
  522.     {$IFC NOT GENERATINGCFM}
  523.     INLINE $7036, $AAA3;
  524.     {$ENDC}
  525. FUNCTION GetCSequenceKeyFrameRate(seqID: ImageSequence; VAR keyframerate: LONGINT): OSErr;
  526.     {$IFC NOT GENERATINGCFM}
  527.     INLINE $203C, $0008, $004B, $AAA3;
  528.     {$ENDC}
  529. FUNCTION GetCSequencePrevBuffer(seqID: ImageSequence; VAR gworld: GWorldPtr): OSErr;
  530.     {$IFC NOT GENERATINGCFM}
  531.     INLINE $7019, $AAA3;
  532.     {$ENDC}
  533. FUNCTION CDSequenceBusy(seqID: ImageSequence): OSErr;
  534.     {$IFC NOT GENERATINGCFM}
  535.     INLINE $701A, $AAA3;
  536.     {$ENDC}
  537. FUNCTION CDSequenceEnd(seqID: ImageSequence): OSErr;
  538.     {$IFC NOT GENERATINGCFM}
  539.     INLINE $701B, $AAA3;
  540.     {$ENDC}
  541. FUNCTION CDSequenceEquivalentImageDescription(seqID: ImageSequence; newDesc: ImageDescriptionHandle; VAR equivalent: BOOLEAN): OSErr;
  542.     {$IFC NOT GENERATINGCFM}
  543.     INLINE $203C, $000C, $0065, $AAA3;
  544.     {$ENDC}
  545. FUNCTION GetCompressedImageSize(desc: ImageDescriptionHandle; data: Ptr; bufferSize: LONGINT; dataProc: ICMDataProcRecordPtr; VAR dataSize: LONGINT): OSErr;
  546.     {$IFC NOT GENERATINGCFM}
  547.     INLINE $701C, $AAA3;
  548.     {$ENDC}
  549. FUNCTION GetSimilarity(src: PixMapHandle; {CONST}VAR srcRect: Rect; desc: ImageDescriptionHandle; data: Ptr; VAR similarity: Fixed): OSErr;
  550.     {$IFC NOT GENERATINGCFM}
  551.     INLINE $701D, $AAA3;
  552.     {$ENDC}
  553. FUNCTION GetImageDescriptionCTable(desc: ImageDescriptionHandle; VAR ctable: CTabHandle): OSErr;
  554.     {$IFC NOT GENERATINGCFM}
  555.     INLINE $701E, $AAA3;
  556.     {$ENDC}
  557. FUNCTION SetImageDescriptionCTable(desc: ImageDescriptionHandle; ctable: CTabHandle): OSErr;
  558.     {$IFC NOT GENERATINGCFM}
  559.     INLINE $701F, $AAA3;
  560.     {$ENDC}
  561. FUNCTION GetImageDescriptionExtension(desc: ImageDescriptionHandle; VAR extension: Handle; idType: LONGINT; index: LONGINT): OSErr;
  562.     {$IFC NOT GENERATINGCFM}
  563.     INLINE $7020, $AAA3;
  564.     {$ENDC}
  565. FUNCTION AddImageDescriptionExtension(desc: ImageDescriptionHandle; extension: Handle; idType: LONGINT): OSErr;
  566.     {$IFC NOT GENERATINGCFM}
  567.     INLINE $7021, $AAA3;
  568.     {$ENDC}
  569. FUNCTION SetImageDescriptionExtension(desc: ImageDescriptionHandle; extension: Handle; idType: LONGINT): OSErr;
  570.     {$IFC NOT GENERATINGCFM}
  571.     INLINE $7021, $AAA3;
  572.     {$ENDC}
  573. FUNCTION RemoveImageDescriptionExtension(VAR desc: ImageDescriptionPtr; idType: LONGINT; index: LONGINT): OSErr;
  574.     {$IFC NOT GENERATINGCFM}
  575.     INLINE $203C, $000C, $003A, $AAA3;
  576.     {$ENDC}
  577. FUNCTION CountImageDescriptionExtensionType(VAR desc: ImageDescriptionPtr; idType: LONGINT; VAR count: LONGINT): OSErr;
  578.     {$IFC NOT GENERATINGCFM}
  579.     INLINE $203C, $000C, $003B, $AAA3;
  580.     {$ENDC}
  581. FUNCTION GetNextImageDescriptionExtensionType(VAR desc: ImageDescriptionPtr; VAR idType: LONGINT): OSErr;
  582.     {$IFC NOT GENERATINGCFM}
  583.     INLINE $203C, $0008, $003C, $AAA3;
  584.     {$ENDC}
  585. FUNCTION FindCodec(cType: CodecType; specCodec: CodecComponent; VAR compressor: CompressorComponent; VAR decompressor: DecompressorComponent): OSErr;
  586.     {$IFC NOT GENERATINGCFM}
  587.     INLINE $7023, $AAA3;
  588.     {$ENDC}
  589. FUNCTION CompressPicture(srcPicture: PicHandle; dstPicture: PicHandle; quality: CodecQ; cType: CodecType): OSErr;
  590.     {$IFC NOT GENERATINGCFM}
  591.     INLINE $7024, $AAA3;
  592.     {$ENDC}
  593. FUNCTION FCompressPicture(srcPicture: PicHandle; dstPicture: PicHandle; colorDepth: INTEGER; clut: CTabHandle; quality: CodecQ; doDither: INTEGER; compressAgain: INTEGER; progressProc: ICMProgressProcRecordPtr; cType: CodecType; codec: CompressorComponent): OSErr;
  594.     {$IFC NOT GENERATINGCFM}
  595.     INLINE $7025, $AAA3;
  596.     {$ENDC}
  597. FUNCTION CompressPictureFile(srcRefNum: INTEGER; dstRefNum: INTEGER; quality: CodecQ; cType: CodecType): OSErr;
  598.     {$IFC NOT GENERATINGCFM}
  599.     INLINE $7026, $AAA3;
  600.     {$ENDC}
  601. FUNCTION FCompressPictureFile(srcRefNum: INTEGER; dstRefNum: INTEGER; colorDepth: INTEGER; clut: CTabHandle; quality: CodecQ; doDither: INTEGER; compressAgain: INTEGER; progressProc: ICMProgressProcRecordPtr; cType: CodecType; codec: CompressorComponent): OSErr;
  602.     {$IFC NOT GENERATINGCFM}
  603.     INLINE $7027, $AAA3;
  604.     {$ENDC}
  605. FUNCTION GetPictureFileHeader(refNum: INTEGER; VAR frame: Rect; VAR header: OpenCPicParams): OSErr;
  606.     {$IFC NOT GENERATINGCFM}
  607.     INLINE $7028, $AAA3;
  608.     {$ENDC}
  609. FUNCTION DrawPictureFile(refNum: INTEGER; {CONST}VAR frame: Rect; progressProc: ICMProgressProcRecordPtr): OSErr;
  610.     {$IFC NOT GENERATINGCFM}
  611.     INLINE $7029, $AAA3;
  612.     {$ENDC}
  613. FUNCTION DrawTrimmedPicture(srcPicture: PicHandle; {CONST}VAR frame: Rect; trimMask: RgnHandle; doDither: INTEGER; progressProc: ICMProgressProcRecordPtr): OSErr;
  614.     {$IFC NOT GENERATINGCFM}
  615.     INLINE $702E, $AAA3;
  616.     {$ENDC}
  617. FUNCTION DrawTrimmedPictureFile(srcRefnum: INTEGER; {CONST}VAR frame: Rect; trimMask: RgnHandle; doDither: INTEGER; progressProc: ICMProgressProcRecordPtr): OSErr;
  618.     {$IFC NOT GENERATINGCFM}
  619.     INLINE $702F, $AAA3;
  620.     {$ENDC}
  621. FUNCTION MakeThumbnailFromPicture(picture: PicHandle; colorDepth: INTEGER; thumbnail: PicHandle; progressProc: ICMProgressProcRecordPtr): OSErr;
  622.     {$IFC NOT GENERATINGCFM}
  623.     INLINE $702A, $AAA3;
  624.     {$ENDC}
  625. FUNCTION MakeThumbnailFromPictureFile(refNum: INTEGER; colorDepth: INTEGER; thumbnail: PicHandle; progressProc: ICMProgressProcRecordPtr): OSErr;
  626.     {$IFC NOT GENERATINGCFM}
  627.     INLINE $702B, $AAA3;
  628.     {$ENDC}
  629. FUNCTION MakeThumbnailFromPixMap(src: PixMapHandle; {CONST}VAR srcRect: Rect; colorDepth: INTEGER; thumbnail: PicHandle; progressProc: ICMProgressProcRecordPtr): OSErr;
  630.     {$IFC NOT GENERATINGCFM}
  631.     INLINE $702C, $AAA3;
  632.     {$ENDC}
  633. FUNCTION TrimImage(desc: ImageDescriptionHandle; inData: Ptr; inBufferSize: LONGINT; dataProc: ICMDataProcRecordPtr; outData: Ptr; outBufferSize: LONGINT; flushProc: ICMFlushProcRecordPtr; VAR trimRect: Rect; progressProc: ICMProgressProcRecordPtr): OSErr;
  634.     {$IFC NOT GENERATINGCFM}
  635.     INLINE $702D, $AAA3;
  636.     {$ENDC}
  637. FUNCTION ConvertImage(srcDD: ImageDescriptionHandle; srcData: Ptr; colorDepth: INTEGER; clut: CTabHandle; accuracy: CodecQ; quality: CodecQ; cType: CodecType; codec: CodecComponent; dstDD: ImageDescriptionHandle; dstData: Ptr): OSErr;
  638.     {$IFC NOT GENERATINGCFM}
  639.     INLINE $7030, $AAA3;
  640.     {$ENDC}
  641. FUNCTION GetCompressedPixMapInfo(pix: PixMapPtr; VAR desc: ImageDescriptionHandle; VAR data: Ptr; VAR bufferSize: LONGINT; VAR dataProc: ICMDataProcRecord; VAR progressProc: ICMProgressProcRecord): OSErr;
  642.     {$IFC NOT GENERATINGCFM}
  643.     INLINE $7037, $AAA3;
  644.     {$ENDC}
  645. FUNCTION SetCompressedPixMapInfo(pix: PixMapPtr; desc: ImageDescriptionHandle; data: Ptr; bufferSize: LONGINT; dataProc: ICMDataProcRecordPtr; progressProc: ICMProgressProcRecordPtr): OSErr;
  646.     {$IFC NOT GENERATINGCFM}
  647.     INLINE $7038, $AAA3;
  648.     {$ENDC}
  649. PROCEDURE StdPix(src: PixMapPtr; {CONST}VAR srcRect: Rect; matrix: MatrixRecordPtr; mode: INTEGER; mask: RgnHandle; matte: PixMapPtr; {CONST}VAR matteRect: Rect; flags: INTEGER);
  650.     {$IFC NOT GENERATINGCFM}
  651.     INLINE $700C, $AAA3;
  652.     {$ENDC}
  653. FUNCTION TransformRgn(matrix: MatrixRecordPtr; rgn: RgnHandle): OSErr;
  654.     {$IFC NOT GENERATINGCFM}
  655.     INLINE $7039, $AAA3;
  656.     {$ENDC}
  657. {$ENDC}
  658. {$IFC FOR_SYSTEM7_AND_SYSTEM8_DEPRECATED }
  659. {
  660. **********
  661.     preview stuff
  662. **********
  663. }
  664. PROCEDURE SFGetFilePreview(where: Point; prompt: Str255; fileFilter: FileFilterUPP; numTypes: INTEGER; typeList: ConstSFTypeListPtr; dlgHook: DlgHookUPP; VAR reply: SFReply);
  665.     {$IFC NOT GENERATINGCFM}
  666.     INLINE $7041, $AAA3;
  667.     {$ENDC}
  668. PROCEDURE SFPGetFilePreview(where: Point; prompt: Str255; fileFilter: FileFilterUPP; numTypes: INTEGER; typeList: ConstSFTypeListPtr; dlgHook: DlgHookUPP; VAR reply: SFReply; dlgID: INTEGER; filterProc: ModalFilterUPP);
  669.     {$IFC NOT GENERATINGCFM}
  670.     INLINE $7042, $AAA3;
  671.     {$ENDC}
  672. PROCEDURE StandardGetFilePreview(fileFilter: FileFilterUPP; numTypes: INTEGER; typeList: ConstSFTypeListPtr; VAR reply: StandardFileReply);
  673.     {$IFC NOT GENERATINGCFM}
  674.     INLINE $7043, $AAA3;
  675.     {$ENDC}
  676. PROCEDURE CustomGetFilePreview(fileFilter: FileFilterYDUPP; numTypes: INTEGER; typeList: ConstSFTypeListPtr; VAR reply: StandardFileReply; dlgID: INTEGER; where: Point; dlgHook: DlgHookYDUPP; filterProc: ModalFilterYDUPP; activeList: ActivationOrderListPtr; activateProc: ActivateYDUPP; yourDataPtr: UNIV Ptr);
  677.     {$IFC NOT GENERATINGCFM}
  678.     INLINE $7044, $AAA3;
  679.     {$ENDC}
  680. {$ENDC}
  681. {$IFC FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE }
  682. FUNCTION MakeFilePreview(resRefNum: INTEGER; progress: ICMProgressProcRecordPtr): OSErr;
  683.     {$IFC NOT GENERATINGCFM}
  684.     INLINE $7045, $AAA3;
  685.     {$ENDC}
  686. FUNCTION AddFilePreview(resRefNum: INTEGER; previewType: OSType; previewData: Handle): OSErr;
  687.     {$IFC NOT GENERATINGCFM}
  688.     INLINE $7046, $AAA3;
  689.     {$ENDC}
  690.  
  691. CONST
  692.     sfpItemPreviewAreaUser        = 11;
  693.     sfpItemPreviewStaticText    = 12;
  694.     sfpItemPreviewDividerUser    = 13;
  695.     sfpItemCreatePreviewButton    = 14;
  696.     sfpItemShowPreviewButton    = 15;
  697.  
  698.  
  699. TYPE
  700.     PreviewResourceRecordPtr = ^PreviewResourceRecord;
  701.     PreviewResourceRecord = RECORD
  702.         modDate:                LONGINT;
  703.         version:                INTEGER;
  704.         resType:                OSType;
  705.         resID:                    INTEGER;
  706.     END;
  707.  
  708.     PreviewResourcePtr                    = ^PreviewResourceRecord;
  709.     PreviewResource                        = ^PreviewResourcePtr;
  710. PROCEDURE AlignScreenRect(VAR rp: Rect; alignmentProc: ICMAlignmentProcRecordPtr);
  711.     {$IFC NOT GENERATINGCFM}
  712.     INLINE $203C, $0008, $004C, $AAA3;
  713.     {$ENDC}
  714. PROCEDURE AlignWindow(wp: WindowPtr; front: BOOLEAN; {CONST}VAR alignmentRect: Rect; alignmentProc: ICMAlignmentProcRecordPtr);
  715.     {$IFC NOT GENERATINGCFM}
  716.     INLINE $203C, $000E, $004D, $AAA3;
  717.     {$ENDC}
  718. PROCEDURE DragAlignedWindow(wp: WindowPtr; startPt: Point; VAR boundsRect: Rect; VAR alignmentRect: Rect; alignmentProc: ICMAlignmentProcRecordPtr);
  719.     {$IFC NOT GENERATINGCFM}
  720.     INLINE $203C, $0014, $004E, $AAA3;
  721.     {$ENDC}
  722. FUNCTION DragAlignedGrayRgn(theRgn: RgnHandle; startPt: Point; VAR boundsRect: Rect; VAR slopRect: Rect; axis: INTEGER; actionProc: UniversalProcPtr; VAR alignmentRect: Rect; alignmentProc: ICMAlignmentProcRecordPtr): LONGINT;
  723.     {$IFC NOT GENERATINGCFM}
  724.     INLINE $203C, $001E, $004F, $AAA3;
  725.     {$ENDC}
  726. FUNCTION SetCSequenceDataRateParams(seqID: ImageSequence; params: DataRateParamsPtr): OSErr;
  727.     {$IFC NOT GENERATINGCFM}
  728.     INLINE $203C, $0008, $0050, $AAA3;
  729.     {$ENDC}
  730. FUNCTION SetCSequenceFrameNumber(seqID: ImageSequence; frameNumber: LONGINT): OSErr;
  731.     {$IFC NOT GENERATINGCFM}
  732.     INLINE $203C, $0008, $0051, $AAA3;
  733.     {$ENDC}
  734. FUNCTION NewImageGWorld(VAR gworld: GWorldPtr; idh: ImageDescriptionHandle; flags: GWorldFlags): QDErr;
  735.     {$IFC NOT GENERATINGCFM}
  736.     INLINE $203C, $000C, $0052, $AAA3;
  737.     {$ENDC}
  738. FUNCTION GetCSequenceDataRateParams(seqID: ImageSequence; params: DataRateParamsPtr): OSErr;
  739.     {$IFC NOT GENERATINGCFM}
  740.     INLINE $203C, $0008, $0053, $AAA3;
  741.     {$ENDC}
  742. FUNCTION GetCSequenceFrameNumber(seqID: ImageSequence; VAR frameNumber: LONGINT): OSErr;
  743.     {$IFC NOT GENERATINGCFM}
  744.     INLINE $203C, $0008, $0054, $AAA3;
  745.     {$ENDC}
  746. FUNCTION GetBestDeviceRect(VAR gdh: GDHandle; VAR rp: Rect): OSErr;
  747.     {$IFC NOT GENERATINGCFM}
  748.     INLINE $203C, $0008, $0055, $AAA3;
  749.     {$ENDC}
  750. FUNCTION SetSequenceProgressProc(seqID: ImageSequence; VAR progressProc: ICMProgressProcRecord): OSErr;
  751.     {$IFC NOT GENERATINGCFM}
  752.     INLINE $203C, $0008, $0056, $AAA3;
  753.     {$ENDC}
  754. FUNCTION GDHasScale(gdh: GDHandle; depth: INTEGER; VAR scale: Fixed): OSErr;
  755.     {$IFC NOT GENERATINGCFM}
  756.     INLINE $203C, $000A, $005A, $AAA3;
  757.     {$ENDC}
  758. FUNCTION GDGetScale(gdh: GDHandle; VAR scale: Fixed; VAR flags: INTEGER): OSErr;
  759.     {$IFC NOT GENERATINGCFM}
  760.     INLINE $203C, $000C, $005B, $AAA3;
  761.     {$ENDC}
  762. FUNCTION GDSetScale(gdh: GDHandle; scale: Fixed; flags: INTEGER): OSErr;
  763.     {$IFC NOT GENERATINGCFM}
  764.     INLINE $203C, $000A, $005C, $AAA3;
  765.     {$ENDC}
  766. FUNCTION ICMShieldSequenceCursor(seqID: ImageSequence): OSErr;
  767.     {$IFC NOT GENERATINGCFM}
  768.     INLINE $203C, $0004, $0062, $AAA3;
  769.     {$ENDC}
  770. PROCEDURE ICMDecompressComplete(seqID: ImageSequence; err: OSErr; flag: INTEGER; completionRtn: ICMCompletionProcRecordPtr);
  771.     {$IFC NOT GENERATINGCFM}
  772.     INLINE $203C, $000C, $0063, $AAA3;
  773.     {$ENDC}
  774. FUNCTION SetDSequenceTimeCode(seqID: ImageSequence; timeCodeFormat: UNIV Ptr; timeCodeTime: UNIV Ptr): OSErr;
  775.     {$IFC NOT GENERATINGCFM}
  776.     INLINE $203C, $000C, $0064, $AAA3;
  777.     {$ENDC}
  778. FUNCTION CDSequenceNewMemory(seqID: ImageSequence; VAR data: Ptr; dataSize: Size; dataUse: LONGINT; memoryGoneProc: ICMMemoryDisposedUPP; refCon: UNIV Ptr): OSErr;
  779.     {$IFC NOT GENERATINGCFM}
  780.     INLINE $203C, $0018, $0066, $AAA3;
  781.     {$ENDC}
  782. FUNCTION CDSequenceDisposeMemory(seqID: ImageSequence; data: Ptr): OSErr;
  783.     {$IFC NOT GENERATINGCFM}
  784.     INLINE $203C, $0008, $0067, $AAA3;
  785.     {$ENDC}
  786. FUNCTION CDSequenceNewDataSource(seqID: ImageSequence; VAR sourceID: ImageSequenceDataSource; sourceType: OSType; sourceInputNumber: LONGINT; dataDescription: Handle; transferProc: UNIV Ptr; refCon: UNIV Ptr): OSErr;
  787.     {$IFC NOT GENERATINGCFM}
  788.     INLINE $203C, $001C, $0068, $AAA3;
  789.     {$ENDC}
  790. FUNCTION CDSequenceDisposeDataSource(sourceID: ImageSequenceDataSource): OSErr;
  791.     {$IFC NOT GENERATINGCFM}
  792.     INLINE $203C, $0004, $0069, $AAA3;
  793.     {$ENDC}
  794. FUNCTION CDSequenceSetSourceData(sourceID: ImageSequenceDataSource; data: UNIV Ptr): OSErr;
  795.     {$IFC NOT GENERATINGCFM}
  796.     INLINE $203C, $0008, $006A, $AAA3;
  797.     {$ENDC}
  798. FUNCTION CDSequenceChangedSourceData(sourceID: ImageSequenceDataSource): OSErr;
  799.     {$IFC NOT GENERATINGCFM}
  800.     INLINE $203C, $0004, $006B, $AAA3;
  801.     {$ENDC}
  802. FUNCTION PtInDSequenceData(seqID: ImageSequence; data: UNIV Ptr; dataSize: Size; where: Point; VAR hit: BOOLEAN): OSErr;
  803.     {$IFC NOT GENERATINGCFM}
  804.     INLINE $203C, $0014, $006C, $AAA3;
  805.     {$ENDC}
  806.  
  807. CONST
  808.     identityMatrixType            = $00;                            {  result if matrix is identity  }
  809.     translateMatrixType            = $01;                            {  result if matrix translates  }
  810.     scaleMatrixType                = $02;                            {  result if matrix scales  }
  811.     scaleTranslateMatrixType    = $03;                            {  result if matrix scales and translates  }
  812.     linearMatrixType            = $04;                            {  result if matrix is general 2 x 2  }
  813.     linearTranslateMatrixType    = $05;                            {  result if matrix is general 2 x 2 and translates  }
  814.     perspectiveMatrixType        = $06;                            {  result if matrix is general 3 x 3  }
  815.  
  816.  
  817. TYPE
  818.     MatrixFlags                            = INTEGER;
  819. FUNCTION GetMatrixType({CONST}VAR m: MatrixRecord): INTEGER;
  820.     {$IFC NOT GENERATINGCFM}
  821.     INLINE $7014, $ABC2;
  822.     {$ENDC}
  823. PROCEDURE CopyMatrix({CONST}VAR m1: MatrixRecord; VAR m2: MatrixRecord);
  824.     {$IFC NOT GENERATINGCFM}
  825.     INLINE $7020, $ABC2;
  826.     {$ENDC}
  827. FUNCTION EqualMatrix({CONST}VAR m1: MatrixRecord; {CONST}VAR m2: MatrixRecord): BOOLEAN;
  828.     {$IFC NOT GENERATINGCFM}
  829.     INLINE $7021, $ABC2;
  830.     {$ENDC}
  831. PROCEDURE SetIdentityMatrix(VAR matrix: MatrixRecord);
  832.     {$IFC NOT GENERATINGCFM}
  833.     INLINE $7015, $ABC2;
  834.     {$ENDC}
  835. PROCEDURE TranslateMatrix(VAR m: MatrixRecord; deltaH: Fixed; deltaV: Fixed);
  836.     {$IFC NOT GENERATINGCFM}
  837.     INLINE $7019, $ABC2;
  838.     {$ENDC}
  839. PROCEDURE RotateMatrix(VAR m: MatrixRecord; degrees: Fixed; aboutX: Fixed; aboutY: Fixed);
  840.     {$IFC NOT GENERATINGCFM}
  841.     INLINE $7016, $ABC2;
  842.     {$ENDC}
  843. PROCEDURE ScaleMatrix(VAR m: MatrixRecord; scaleX: Fixed; scaleY: Fixed; aboutX: Fixed; aboutY: Fixed);
  844.     {$IFC NOT GENERATINGCFM}
  845.     INLINE $7017, $ABC2;
  846.     {$ENDC}
  847. PROCEDURE SkewMatrix(VAR m: MatrixRecord; skewX: Fixed; skewY: Fixed; aboutX: Fixed; aboutY: Fixed);
  848.     {$IFC NOT GENERATINGCFM}
  849.     INLINE $7018, $ABC2;
  850.     {$ENDC}
  851. FUNCTION TransformFixedPoints({CONST}VAR m: MatrixRecord; VAR fpt: FixedPoint; count: LONGINT): OSErr;
  852.     {$IFC NOT GENERATINGCFM}
  853.     INLINE $7022, $ABC2;
  854.     {$ENDC}
  855. FUNCTION TransformPoints({CONST}VAR mp: MatrixRecord; VAR pt1: Point; count: LONGINT): OSErr;
  856.     {$IFC NOT GENERATINGCFM}
  857.     INLINE $7023, $ABC2;
  858.     {$ENDC}
  859. FUNCTION TransformFixedRect({CONST}VAR m: MatrixRecord; VAR fr: FixedRect; VAR fpp: FixedPoint): BOOLEAN;
  860.     {$IFC NOT GENERATINGCFM}
  861.     INLINE $7024, $ABC2;
  862.     {$ENDC}
  863. FUNCTION TransformRect({CONST}VAR m: MatrixRecord; VAR r: Rect; VAR fpp: FixedPoint): BOOLEAN;
  864.     {$IFC NOT GENERATINGCFM}
  865.     INLINE $7025, $ABC2;
  866.     {$ENDC}
  867. FUNCTION InverseMatrix({CONST}VAR m: MatrixRecord; VAR im: MatrixRecord): BOOLEAN;
  868.     {$IFC NOT GENERATINGCFM}
  869.     INLINE $701C, $ABC2;
  870.     {$ENDC}
  871. PROCEDURE ConcatMatrix({CONST}VAR a: MatrixRecord; VAR b: MatrixRecord);
  872.     {$IFC NOT GENERATINGCFM}
  873.     INLINE $701B, $ABC2;
  874.     {$ENDC}
  875. PROCEDURE RectMatrix(VAR matrix: MatrixRecord; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  876.     {$IFC NOT GENERATINGCFM}
  877.     INLINE $701E, $ABC2;
  878.     {$ENDC}
  879. PROCEDURE MapMatrix(VAR matrix: MatrixRecord; {CONST}VAR fromRect: Rect; {CONST}VAR toRect: Rect);
  880.     {$IFC NOT GENERATINGCFM}
  881.     INLINE $701D, $ABC2;
  882.     {$ENDC}
  883. {$ENDC}
  884. {$ALIGN RESET}
  885. {$POP}
  886.  
  887. {$SETC UsingIncludes := ImageCompressionIncludes}
  888.  
  889. {$ENDC} {__IMAGECOMPRESSION__}
  890.  
  891. {$IFC NOT UsingIncludes}
  892.  END.
  893. {$ENDC}
  894.